This invention relates to the field of microprocessor and microcontroller evaluation and testing, and in particular it relates to an integrated evaluation and debug environment that can be remotely accessed over the Internet or other data communication system.
Integrated Debug Environments (IDE) are well known in the art of electronic design and integrated circuit testing and evaluation. An IDE is a combination of hardware and software elements that permits an engineer to operate and test an integrated circuit such as a microprocessor or a microcontroller (collectively referred to as xe2x80x9cprocessorsxe2x80x9d), which is usually incorporated into an electronic system including other connected elements such as, for example, memory, clocks, and input/output circuitry (hereinafter referred to as the xe2x80x9ctarget systemxe2x80x9d). An IDE typically provides an engineer or programmer with a substantial amount of control and insight into the detailed workings of the target system, allowing the user to control the input signals, the memory contents, the speed of operation, and other aspects of the target""s operation. An IDE typically also allows the user to observe the operation of the target in detail, typically using a logic analyzer and other devices to monitor various externally observable circuit elements, as well as the processor state at selected points during program execution. An IDE may also interface with in-circuit emulation functionality that may be built into the target system, which can allow the user to obtain information regarding even the internal operation of an integrated circuit, such as a microprocessor. An IDE provides an interface for a user to do something as simple as running a program on the target system and observing the output, or as complex as debugging a sophisticated program that is run by a microcontroller that is installed in an operating product, such as a computer or a printer. Debugging may include determining where a program is not behaving as expected and why, and may involve taking control of the clock, memory, I/O and other aspects of the target system and comprehensively analyzing the behavior of the processor in response to various combinations of stimuli. An engineer can also use an IDE to xe2x80x9ctunexe2x80x9d a system to optimize performance.
Setting up an IDE can be a costly undertaking. Each person or company who wants to evaluate a processor or to debug a program running on a certain processor must set up and configure an IDE for that processor. Referring to FIG. 1, an IDE typically includes a host computer 104 including target control software and appropriate software toolsets (compilers, linkers, library files, locators, etc.), a target system 108 (which is often a printed circuit board holding the target device and peripheral components), memory emulator 110, debug monitor 112, logic analyzer 114, appropriate connectors 116, and a user interface 106 (typically a computer or workstation with appropriate software) having a connection 106 to the host computer. Memory emulator 110 may alternatively be a ROM emulator or an overlay memory, and it may be connected to the target system 108 directly or through a debug monitor or other means familiar to those skilled in the art. The software toolset must be available for producing code that is executable on the target system. Such a toolset typically includes compilers, linkers, locators, interpreters and debuggers, which are typically specialized for taking a program from a particular high level language (e.g. C++) and turning it into code that can be executed on a particular target (e.g. a 486-class microprocessor). Additional capabilities may be provided by browsers, profilers and assorted libraries. In order to evaluate a target device or to debug a program, a complete IDE system must be obtained or constructed for each target to be tested or debugged, at the cost of acquiring all of the required hardware and software, plus the (often substantial) cost of installing, configuring, and debugging the IDE system. This cost is often too high to allow an engineer to evaluate how a program will run on each of several different microcontrollers, so the engineer has to select one or a few target devices to test, because the cost of setting up an IDE to test additional target devices is prohibitive. A system is needed where a shared IDE can be set up at a central location to perform test and debug functions for a particular target system, or a class of target systems, such that the IDE can be accessed by remote users. The desired system would allow the debug operation to be completely controlled by the user from a remote location, as though the user were physically operating the IDE host machine locally.
The user interface of a modern IDE is itself a complex computer program, or a collection of programs. The user interface of an IDE is typically installed on a computer that is dedicated, at least in part, to operating the IDE. The user interface computer is usually either directly connected to the IDE host computer (or it may be the host computer), or it is connected to the host computer by a private network. Interface software is typically platform specific, so that a different user interface program is typically required for each type of computer (e.g. x86, Sparc, HP, Macintosh) that may be used as an interface. Furthermore, the user must locate, acquire, install and debug the user interface software on a suitable computer before the IDE can be used. A user interface is desired that can be easily located, downloaded over a network and installed on a user""s machine so that it will be a simple task to set up a fully functional user interface at a location remote from the host computer, so that the interface could communicate with the host over a network, eliminating the need for the user to be physically proximate to the host machine.
FIG. 2 shows a prior, remotely accessible target device testing system 200, known to the inventor, in which host computer 204 was located in a central location. Referring to FIG. 2, several different processors were configured into target systems 202A-D which were attached to host computer 204, such that programs generated by the host could be executed on target systems 202 as selected by a user. A user could connect a remote computer 206 to host system 204, using modems 208A-B to communicate across telephone network 210. The user would use a command line interface to have a computer program run on a selected target system 208 under the control of host 204. The program""s output was then returned to user""s computer 206 via the modems 208A-B and phone system 210. To use this system, the user only needed basic telecommunication software and a modem; the interface permitted only limited control of the debug environment. While this system was useful for certain limited applications, it was not a substitute for a full-fledged debug environment, and it did not lend itself well to allowing customers to dial-in to experiment with the target devices.
It is desired to provide a full-featured IDE, with one or more associated target systems, that is fully operable from a remote location. In other words, it is desirable for a remote user to have an interface to a comprehensive debug system that is similar or identical to an interface that is typically used with a local IDE system. Such a system is not known to exist in the prior art. It is further desirable for a remote user to be able to obtain the interface software that is required at the remote location by downloading it from a host computer, and it is desirable that the interface software be operable on many types of computers that remote users may be using. It is further desirable for a system that provides a familiar interface to a remote user who is accustomed to operating IDE systems.
The above-referenced deficiencies in the prior art are addressed by the present invention, which provides a remotely accessible, full-featured IDE. Furthermore, in preferred embodiments, the present invention provides a preconfigured, downloadable, platform-independent user interface for a remote user, thus enabling the user to enjoy full control of a complete IDE system to test a selected target system from a remote location. The communication channel between the remote user and the host installation may be the Internet, or it may be a private network or other channel such as a dial-up telephone connection. The user interface may be written in a platform independent language, such as Java. The Java language is particularly well suited for use in this invention because it is platform independent, became Java interpreters are universally available to Internet users, and because Java bytecode was designed to be quickly and reliably transmitted over the Internet and similar networks and to enable high-performance execution on multiple platforms.
This invention is particularly well suited for allowing manufacturers, such as microprocessor and microcontroller manufacturers, to provide their customers with a low-cost and relatively simple way to gain access to an IDE for sampling, testing, and debugging software on their processor products. In presently preferred embodiments, a manufacturer may use this invention to set up an IDE comprising a host computer (which may also be an Internet web server), selectably connected to one or more target systems that it wants to make available to its remote customers. The host/target control computer may be equipped with appropriate toolsets used by persons skilled in the art (compilers, linkers, locators, etc.) to receive program files in various source code languages from users and to produce corresponding executable code to run on the various target systems that may be connected to the host and made available to the users. All of the target-specific software and hardware that is needed to operate or test code on a selected processor may be provided at the host processor, so that the user only needs a generic interface on a remote terminal to be able to operate a full featured IDE. In preferred embodiments of the invention, the host computer and the remote terminal may have a server/client relationship, as is familiar to those skilled in the art.
In a preferred embodiment of the present invention, a user wishing to evaluate the performance of her software on a selected processor manufactured by company X will connect to company X""s site on the Internet using her computer, which may be a PC, a Macintosh, a Sparc workstation, or another type of terminal that supports Internet connectivity and a Java interpreter. The user will then be provided with information from the host computer regarding the types of target systems that are available for remote use and other details of the test environment provided by company X. If the user elects to proceed, she will be instructed to download a Java program to her computer which will, when executed, implement a full-featured IDE user interface (including any required communication capabilities) on the user""s local computer to control the operation of the host computer and its related peripherals. Through the local user interface, the user will then configure the test system as desired, upload (from the remote terminal to the host system) any programs that she wants to run on the target system, direct the compilation and other functions performed by the host computer, and then receive the results produced by execution of her program under the selected operating conditions. In addition to the output generated by her program, the user will have full access to the IDE facilities associated with the host computer, including perhaps the ability to monitor bus activity, timing, I/O activity, memory activity, and full debug functionality. This invention will thus allow a manufacturer to enable its customers to xe2x80x9ctest-drivexe2x80x9d its processors without requiring customers to invest in costly test apparatus and software. It will also permit software developers to debug versions of software optimized for various diverse processors without requiring them to install a debug system for each processor.
The present invention will thus permit an IDE to be constructed to operate and debug one or more processors and to be shared by local and remote users. Remote users wishing to run or debug programs on a selected processor will no longer have to build a dedicated IDE (or travel to a site where one is available) to do so. This invention will be useful for software developers, who can run and debug software on target systems made available using this invention; for customers who wish to xe2x80x9ctest drivexe2x80x9d several different processors before making a purchasing decision; and for processor manufacturers who can use this invention to allow customers to try out their products, as well as to facilitate software development for those products.